﻿using System;
using System.Web.UI;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using TumbaloSoft.Models;
using System.Collections;
using System.Web.Helpers;
using System.IO;
using TumbaloSoft.Helpers;
using TumbaloSoft.Helpers.QueryObjects;

namespace TumbaloSoft.Controllers
{
    public class PagosController : TumbaloController
    {
        static object lockObject = new object();
        public ActionResult Index()
        {
            if (defaultAction != null) return defaultAction;
            int idPropietario = AccountController.getIdPersona(HttpContext);
            IList departamentos;
            List<Cuota> cuotas;
            try
            {
                departamentos = HelperDepartamento.selectByIdPropietario(idPropietario);
                cuotas = new List<Cuota>();
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error buscando departamento", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                foreach (Departamento departamento in departamentos)
                {
                    List<Cuota> cuotaxDepa = HelperCuota.selectCuotasPendientes(departamento.prIdDepartamento);
                    foreach (Cuota cuotaAux in cuotaxDepa)
                    {
                        cuotaAux.prDepartamento = departamento;
                    }
                    cuotas.AddRange(cuotaxDepa);
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error seleccionando las cuotas pendientes", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.ListaCuotas = cuotas;
            return View();
        }

        public ActionResult RegistrarCuota(string error)
        {
            if (defaultAction != null) return defaultAction;

            AdministradorEdificios administrador;
            Edificio ed;
            List<Edificio> listaEdificios = new List<Edificio>();
            try
            {
                if (AccountController.getIdPerfil(HttpContext) == 3)
                {
                    listaEdificios.AddRange(HelperEdificio.selectEdificiosAdministrados());
                }
                else
                {
                    administrador = HelperAdministrador.selectByIdPersona(AccountController.getIdPersona(HttpContext));
                    if (administrador == null) ed = null;
                    else
                    {
                        ed = HelperEdificio.selectById(HelperAdministrador.EdificioAdministradoSelect(administrador.prIdAdministrador));
                        listaEdificios.Add(ed);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de conección", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.idEdificio = -1;
            ViewBag.listaEdificios = listaEdificios;
            ViewBag.errorDepa = error;
            return View();
        }

        public string RegistrarCuotaExtraordinariaPorDepartamento(Cuota cuota, List<GastoPresupuesto> gastosMensuales)
        {
            if (!HelperDepartamento.verificaNumeroDepa(cuota.prDepartamento))
            {
                return "Numero de departamento inexistente";
            }

            double monto = 0;
            cuota.prSubtotales = new List<DetalleCuota>();
            foreach (GastoPresupuesto gasto in gastosMensuales)
            {
                cuota.prSubtotales.Add(new DetalleCuota(0, gasto.prDescripcion, gasto.prMonto));
                monto += gasto.prMonto;
            }
            cuota.prTipo = cuota.prTipo;
            try
            {
                cuota.prDepartamento = HelperDepartamento.selectByNumeroDepartamentoEnEdificio(cuota.prDepartamento);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error al buscar departamento", ex);
                return "Exception";
            }
            cuota.prMonto = monto;
            cuota.prFechaEmision = DateTime.Today;
            cuota.prFechaPago = null;
            cuota.prFechaVencimiento = DateTime.Today.AddMonths(1);
            cuota.prEstado = "PENDIENTE";
            try
            {
                lock (lockObject)
                {
                    HelperCuota.insert(cuota);
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error al insertar cuota", ex);
                return "Exception";
            }
            return "";
        }

        [HttpPost]
        public ActionResult RegistrarCuota(Cuota cuota, List<string> conceptos, List<double> subtotales, int extension, string incluyeContrato, int pideSugerencia, int pideContrato)
        {
            if (defaultAction != null) return defaultAction;
            AdministradorEdificios administrador;
            Edificio ed;
            List<Edificio> listaEdificios = new List<Edificio>();
            ViewBag.idEdificio = cuota.prDepartamento.prEdificio.prIdEdificio;
            try
            {
                if (AccountController.getIdPerfil(HttpContext) == 3)
                {
                    listaEdificios.AddRange(HelperEdificio.selectEdificiosAdministrados());
                }
                else
                {
                    administrador = HelperAdministrador.selectByIdPersona(AccountController.getIdPersona(HttpContext));
                    if (administrador == null) ed = null;
                    else
                    {
                        ed = HelperEdificio.selectById(HelperAdministrador.EdificioAdministradoSelect(administrador.prIdAdministrador));
                        listaEdificios.Add(ed);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de conección", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            Edificio edificio;
            ViewBag.listaEdificios = listaEdificios;
            try
            {
                //No se verifica si el edificio existe o no porque se reemplazara por un combobox
                edificio = HelperEdificio.selectById(cuota.prDepartamento.prEdificio.prIdEdificio);
                edificio.prListaDepartamentos = HelperDepartamento.selectByIdEdificio(edificio.prIdEdificio);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            if (pideSugerencia == 1)
            {
                ViewBag.sugerencia = SugerirCuota(cuota.prDepartamento.prEdificio.prIdEdificio);
                ViewBag.idEdificio = cuota.prDepartamento.prEdificio.prIdEdificio;
                return View(cuota);
            }
            if (incluyeContrato == "0" && pideContrato == 1)
            {
                List<ContratoMantenimiento> contratos;
                try
                {
                    contratos = HelperContratoMantenimiento.selectAllActuales(cuota.prDepartamento.prEdificio);
                }
                catch (Exception ex)
                {
                    Logger.Current.Error("Error de coneccion", ex);
                    return View("~/Views/Shared/Error.cshtml");
                }
                List<GastoPresupuesto> gastos = new List<GastoPresupuesto>();
                foreach (ContratoMantenimiento contrato in contratos)
                {
                    gastos.Add(new GastoPresupuesto(contrato));
                }
                if (cuota.prTipo == "FIJA")
                    ViewBag.lastTipo = 1;
                if (cuota.prTipo == "PRORRATEO")
                    ViewBag.lastTipo = 2;
                ViewBag.sugerencia = SugerirCuota(cuota.prDepartamento.prEdificio.prIdEdificio);
                ViewBag.lineaCuotaxContrato = gastos;
                ViewBag.edificioDelContrato = cuota.prDepartamento.prEdificio.prIdEdificio;
                ViewBag.incluyeContrato = 1;
                return View(cuota);
            }
            List<GastoPresupuesto> gastosMensuales = new List<GastoPresupuesto>();
            for (int k = 0; k < conceptos.Count; k++)
            {
                gastosMensuales.Add(new GastoPresupuesto(conceptos[k], subtotales[k]));
            }
            int tipo = 0;

            if (cuota.prTipo == "EXTRAORDINARIA")
            {
                if (extension == 1)
                {
                    string valorError;
                    if ((valorError = RegistrarCuotaExtraordinariaPorDepartamento(cuota, gastosMensuales)) == "")
                    {
                        ViewBag.mensaje = "Se registro la cuota extraordinaria " + cuota.prIdCuota + " para el departamento " + cuota.prDepartamento.prNumeroDepartamento;
                        return View("~/Views/Shared/Exito.cshtml");
                    }
                    else
                        if (valorError == "Exception")
                        {
                            return View("~/Views/Shared/Error.cshtml");
                        }
                        else
                        {
                            ViewBag.errorDepa = valorError;
                            return View();
                        }
                }
                else tipo = 0;
            }
            if (cuota.prTipo == "FIJA") tipo = 0;
            if (cuota.prTipo == "PRORRATEO") tipo = 1;
            CalculadorCuotaMes calculador = new CalculadorCuotaMes(edificio, gastosMensuales, tipo, 0);
            calculador.hallarCuota();
            lock (lockObject)
            {
                for (int i = 0; i < edificio.prListaDepartamentos.Count; i++)
                {
                    Cuota cuotaI = new Cuota();
                    cuotaI.prTipo = cuota.prTipo;
                    cuotaI.prDepartamento = edificio.prListaDepartamentos[i];
                    cuotaI.prMonto = calculador.prCuotas[i];
                    cuotaI.prFechaEmision = DateTime.Today;
                    cuotaI.prFechaPago = null;
                    cuotaI.prFechaVencimiento = DateTime.Today.AddMonths(1);
                    if (tipo == 0 && cuota.prTipo == "FIJA")
                    {
                        if (edificio.prTieneContometro == "1")
                            cuotaI.prEstado = "ESPERA CONSUMO DE AGUA";
                        else
                            cuotaI.prEstado = "PENDIENTE";
                    }
                    else
                        if (edificio.prTieneContometro == "1")
                            cuotaI.prEstado = "ESPERA CONSUMO DE AGUA";
                        else
                            cuotaI.prEstado = "PENDIENTE";
                    if (cuotaI.prTipo == "EXTRAORDINARIA") cuotaI.prEstado = "PENDIENTE";
                    cuotaI.prSubtotales = new List<DetalleCuota>();
                    foreach (DetalleCuota detalle in calculador.prDetalles)
                    {
                        if (detalle.prNumeroCuota == i) cuotaI.prSubtotales.Add(detalle);
                    }
                    try
                    {
                        if (tipo == 0)
                        {
                            if (!HelperCuota.hayCuotaMes(cuotaI) || cuotaI.prTipo == "EXTRAORDINARIA")
                            {
                                HelperCuota.insert(cuotaI);
                            }
                            else
                            {
                                ViewBag.CuotaYaRegistrada = "La cuota de mantenimiento de este mes para este edificio ya existe.";
                                return View(cuota);
                            }
                        }
                        else
                        {
                            if (!HelperCuota.hayCuotaMes(cuotaI))
                            {
                                HelperCuota.insert(cuotaI);
                            }
                            else
                            {
                                ViewBag.CuotaYaRegistrada = "La cuota de mantenimiento de este mes para este edificio ya existe.";
                                return View(cuota);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Logger.Current.Error("Error al insertar la cuota", ex);
                        return View("~/Views/Shared/Error.cshtml");
                    }
                }
            }
            string tipoC = "";
            if (cuota.prTipo == "FIJA") tipoC = "unica";
            else
                if (cuota.prTipo == "EXTRAORDINARIA") tipoC = "extraordinaria";
                else
                    if (cuota.prTipo == "PRORRATEO") tipoC = "al prorrateo";
            ViewBag.mensaje = "Se registro la cuota " + tipoC + " para el edificio " + edificio.prNombre;
            return View("~/Views/Shared/Exito.cshtml");
        }

        public ActionResult RegistrarComprobante(int prIdCuota)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);

            Cuota cuota = HelperCuota.selectById(prIdCuota);
            Comprobante comprobante = new Comprobante(cuota);
            try
            {
                ViewBag.lista = HelperBanco.selectAll();
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            return View(comprobante);
        }
        [HttpPost]
        public ActionResult RegistrarComprobante(Comprobante comp)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            comp.llenarDatosCuota();
            ModelState.Remove("prDepartamento.prNroPiso");
            if (!ModelState.IsValid)
            {
                return View(comp);
            }
            Cuota cuota;
            try
            {
                cuota = HelperCuota.selectById(comp.prIdCuota);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            Comprobante comprobante = new Comprobante(cuota);
            comprobante.prIdComprobante = comp.prIdComprobante;
            comprobante.prFechaEmisionComprobante = comp.prFechaEmisionComprobante;
            var image = WebImage.GetImageFromRequest();
            if (image != null)
            {
                string filename = Path.GetFileName(image.FileName);
                string extension = Path.GetExtension(image.FileName);
                filename = "Cuota-" + comprobante.prIdCuota + "-Departamento-" + comprobante.prDepartamento.prIdDepartamento + extension;
                var imagePath = Path.Combine(Server.MapPath("../Imagenes/Pagos/" + "Edificio" + comprobante.prDepartamento.prEdificio.prIdEdificio + "/" + "Departamento" + comprobante.prDepartamento.prIdDepartamento), filename);
                try
                {
                    image.Save(imagePath);
                }
                catch (DirectoryNotFoundException ex)
                {
                    try
                    {
                        string edificiosPath = Server.MapPath("../Imagenes/Pagos/" + "Edificio" + comprobante.prDepartamento.prEdificio.prIdEdificio);
                        string relpath = Path.Combine(edificiosPath);
                        System.IO.Directory.CreateDirectory(relpath);
                    }
                    catch (Exception exx) { }
                    string departamentosPath = Server.MapPath("../Imagenes/Pagos/" + "Edificio" + comprobante.prDepartamento.prEdificio.prIdEdificio + "/" + "Departamento" + comprobante.prDepartamento.prIdDepartamento);
                    string finalPath = Path.Combine(departamentosPath);
                    System.IO.Directory.CreateDirectory(finalPath);
                    image.Save(imagePath);
                }
                comprobante.prImagen = Url.Content(Path.Combine("../Imagenes/Pagos/" + "Edificio" + comprobante.prDepartamento.prEdificio.prIdEdificio + "/" + "Departamento" + comprobante.prDepartamento.prIdDepartamento, filename));
            }
            try
            {
                if (!HelperComprobante.existe(comprobante))
                {
                    lock (lockObject)
                    {
                        HelperComprobante.insert(comprobante);
                        return RedirectToAction("index");
                    }
                }
                else
                {
                    TempData["error"] = "El comprobante ya existe";
                    return View(comp);
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error al insertar el comprobante", ex);
                return View("~/Views/Shared/Error.cshtml");
            }

        }
        public ActionResult RegistrarTransferencia(int prIdCuota)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            Cuota cuota;
            Transferencia transferencia;
            try
            {
                cuota = HelperCuota.selectById(prIdCuota);
                transferencia = new Transferencia(cuota);
                ViewBag.lista = HelperBanco.selectAll();
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }

            return View(transferencia);
        }
        [HttpPost]
        public ActionResult RegistrarTransferencia(Transferencia trans)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            trans.llenarDatosCuota();
            try
            {
                ViewBag.lista = HelperBanco.selectAll();
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ModelState.Remove("prDepartamento.prNroPiso");
            if (!ModelState.IsValid)
            {
                return View(trans);
            }
            Cuota cuota;
            try
            {
                cuota = HelperCuota.selectById(trans.prIdCuota);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            Transferencia transferencia = new Transferencia(cuota);
            transferencia.prIdTransferencia = trans.prIdTransferencia;
            transferencia.prBanco = trans.prBanco;
            transferencia.prCuentaBancaria = trans.prCuentaBancaria;
            try
            {
                if (!HelperTransferencia.existe(transferencia))
                {
                    lock (lockObject)
                    {
                        HelperTransferencia.insert(transferencia);
                        return RedirectToAction("index");
                    }
                }
                else
                {
                    TempData["error"] = "La transferencia ya existe";
                    return View(trans);
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error al insertar la transferencia", ex);
                return View("~/Views/Shared/Error.cshtml");
            }

        }
        public ActionResult BuscarPagos()
        {
            if (defaultAction != null) return defaultAction;

            AdministradorEdificios administrador;
            Edificio ed;
            List<Edificio> listaEdificios = new List<Edificio>();
            try
            {
                if (AccountController.getIdPerfil(HttpContext) == 3)
                {
                    listaEdificios.AddRange(HelperEdificio.selectEdificiosAdministrados());
                }
                else
                {
                    administrador = HelperAdministrador.selectByIdPersona(AccountController.getIdPersona(HttpContext));
                    if (administrador == null) ed = null;
                    else
                    {
                        ed = HelperEdificio.selectById(HelperAdministrador.EdificioAdministradoSelect(administrador.prIdAdministrador));
                        listaEdificios.Add(ed);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de conección", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.listaEdificios = listaEdificios;
            return View();
        }
        [HttpPost]
        public ActionResult MostrarPagos(BusquedaPagos busqueda)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos/BuscarPagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            if (busqueda.prTipoPago == null) return RedirectToAction("BuscarPagos");

            if (busqueda.prTipoPago.Contains("comprobante"))
                try
                {
                    ViewBag.ListaComprobantes = HelperComprobante.buscar(busqueda);
                }
                catch (Exception ex)
                {
                    Logger.Current.Error("Error al buscar los comprobantes", ex);
                    return View("~/Views/Shared/Error.cshtml");
                }
            else ViewBag.ListaComprobantes = new List<Comprobante>();
            if (busqueda.prTipoPago.Contains("transferencia"))
                try
                {
                    ViewBag.ListaTransferencias = HelperTransferencia.buscar(busqueda);
                }
                catch (Exception ex)
                {
                    Logger.Current.Error("Error al buscar las transferencias", ex);
                    return View("~/Views/Shared/Error.cshtml");
                }
            else ViewBag.ListaTransferencias = new List<Transferencia>();
            return View();
        }

        public ActionResult BuscarHistorialPagos()
        {
            if (defaultAction != null) return defaultAction;

            return View();
        }
        [HttpPost]
        public ActionResult MostrarHistorialPagos(BusquedaHistorialPagos busqueda)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos/BuscarHistorialPagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            busqueda.prIdPropietario = AccountController.getIdPersona(HttpContext);
            List<Comprobante> comprobantes;
            List<Transferencia> transferencias;
            try
            {
                comprobantes = HelperComprobante.buscarHistorial(busqueda);
                transferencias = HelperTransferencia.buscarHistorial(busqueda);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error al buscar el historial de comprobantes y transferencias", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.ListaComprobantes = comprobantes;
            ViewBag.ListaTransferencias = transferencias;
            return View();
        }

        public ActionResult AprobarComprobante(string prIdComprobante, int prIdCuota)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos/BuscarPagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            Comprobante comprobante;
            try
            {
                comprobante = HelperComprobante.selectById(prIdComprobante, prIdCuota);
                comprobante.prDepartamento = HelperDepartamento.selectById(comprobante.prDepartamento.prIdDepartamento);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            return View(comprobante);
        }
        [HttpPost]
        public ActionResult AprobarComprobante(Comprobante comprobante)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos/BuscarPagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            try
            {
                comprobante.prDepartamento = HelperDepartamento.selectById(comprobante.prDepartamento.prIdDepartamento);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                HelperComprobante.aprobar(comprobante);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error al aprobar el comprobante", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            return RedirectToAction("index");
        }

        public ActionResult AprobarTransferencia(string prIdTransferencia, int prIdCuota)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos/BuscarPagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            Transferencia transferencia;
            try
            {
                transferencia = HelperTransferencia.selectById(prIdTransferencia, prIdCuota);
                transferencia.prBanco = HelperBanco.selectById(transferencia.prBanco.prIdBanco);
                transferencia.prDepartamento = HelperDepartamento.selectById(transferencia.prDepartamento.prIdDepartamento);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            return View(transferencia);
        }
        [HttpPost]
        public ActionResult AprobarTransferencia(Transferencia transferencia)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos/BuscarPagos" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            try
            {
                transferencia.prBanco = HelperBanco.selectById(transferencia.prBanco.prIdBanco);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                HelperTransferencia.aprobar(transferencia);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error al aprobar la transferencia", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            return RedirectToAction("index");
        }

        public ActionResult ReporteCuotaPDF(int prIdCuota, string back)
        {
            if (!AccountController.validarLogueo(HttpContext))
                return RedirectToAction("LogOn", "Account", new { returnUrl = "/pagos/" });
            try
            {
                PersonaNatural personaN = HelperPersonaNatural.selectById(AccountController.getIdPersona(HttpContext));
                ViewBag.nombrePersona = personaN.prNombre + " " + personaN.prApellidoPaterno + " " + personaN.prApellidoMaterno;
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Login Error", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                if (!AccountController.validarPermiso(HttpContext))
                    View("~/Views/Shared/AccesoRestringido.cshtml");
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de permiso", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.permiso = AccountController.getIdPerfil(HttpContext);
            HelperPDF.HtmlToPDF("pagos/ReporteCuota?prIdCuota=" + prIdCuota, "Cuota", 0, this);
            return RedirectToAction(back);
        }

        public ActionResult ReporteCuota(int prIdCuota)
        {
            Cuota cuota;
            try
            {
                cuota = HelperCuota.selectById(prIdCuota);
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de coneccion", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            return View(cuota);
        }

        public ActionResult MostrarEstadoCuenta()
        {
            if (defaultAction != null) return defaultAction;

            int idPropietario = AccountController.getIdPersona(HttpContext);
            IList departamentos;
            List<Cuota> cuotas;
            try
            {
                departamentos = HelperDepartamento.selectByIdPropietario(idPropietario);
                cuotas = new List<Cuota>();
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error buscando departamento", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            try
            {
                foreach (Departamento departamento in departamentos)
                {
                    List<Cuota> cuotaxDepa = HelperCuota.selectEstadoCuenta(departamento.prIdDepartamento);
                    foreach (Cuota cuotaAux in cuotaxDepa)
                    {
                        cuotaAux.prDepartamento = departamento;
                    }
                    cuotas.AddRange(cuotaxDepa);
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error seleccionando las cuotas pendientes", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.ListaCuotas = cuotas;
            return View();

        }

        public ActionResult BuscarMorosidad()
        {
            if (defaultAction != null) return defaultAction;

            AdministradorEdificios administrador;
            Edificio ed;
            List<Edificio> listaEdificios = new List<Edificio>();
            try
            {
                if (AccountController.getIdPerfil(HttpContext) == 3)
                {
                    listaEdificios.AddRange(HelperEdificio.selectEdificiosAdministrados());
                }
                else
                {
                    administrador = HelperAdministrador.selectByIdPersona(AccountController.getIdPersona(HttpContext));
                    if (administrador == null) ed = null;
                    else
                    {
                        ed = HelperEdificio.selectById(HelperAdministrador.EdificioAdministradoSelect(administrador.prIdAdministrador));
                        listaEdificios.Add(ed);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Current.Error("Error de conección", ex);
                return View("~/Views/Shared/Error.cshtml");
            }
            ViewBag.listaEdificios = listaEdificios;
            return View();

        }
        [HttpPost]
        public ActionResult ReporteMorosidad(int prIdEdificio, int tipoReporte)
        {
            if (defaultAction != null) return defaultAction;
            List<Cuota> cuotas = new List<Cuota>();
            ViewBag.tipo = tipoReporte;
            if (tipoReporte == 2)
            {
                try
                {
                    cuotas = HelperCuota.selectMorosos(prIdEdificio);
                }
                catch (Exception ex)
                {
                    Logger.Current.Error("Error seleccionando las cuotas en mora", ex);
                    return View("~/Views/Shared/Error.cshtml");
                }
            }
            else if (tipoReporte == 1)
            {
                try
                {
                    cuotas = HelperCuota.selectAllMes(prIdEdificio);
                }
                catch (Exception ex)
                {
                    Logger.Current.Error("Error seleccionando las cuotas de un edificio", ex);
                    return View("~/Views/Shared/Error.cshtml");
                }
            }
            ViewBag.ListaCuotas = cuotas;
            return View();

        }



        public Double SugerirCuota(int idedificio)
        {
            Double cuota;
            List<Departamento> lista;
            try
            {
                lista = HelperDepartamento.selectByIdEdificio(idedificio);
                if (lista.Count == 0) return 0;

                cuota = HelperEdificio.HallarCuotaSegunGastos(idedificio);

                if (cuota > 0) return cuota / lista.Count();
                else
                {
                    cuota = HelperEdificio.HallarCuotaSegunAreas(idedificio);
                    if (cuota > 0) return cuota / lista.Count();
                    else return 0;
                }
            }
            catch (Exception ex)
            {

                Logger.Current.Error("Error sugiriendo las cuotas de un edificio", ex);
                return 0;
            }

        }
    }
}